package xin.zhiyin.服务.书.实现;

import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import xin.zhiyin.仓库.书.书章节Repository;
import xin.zhiyin.仓库.书.书章节内容Repository;
import xin.zhiyin.仓库.书.书章节内容图片Repository;
import xin.zhiyin.仓库.系统.阿里云OSS配置信息Repository;
import xin.zhiyin.实体.书章节Entity;
import xin.zhiyin.实体.书章节内容图片Entity;
import xin.zhiyin.工具.阿里云OSS.阿里云OSSUtil;
import xin.zhiyin.服务.书.书章节Service;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

@Service
@Transactional(rollbackFor = Exception.class) /*声明式事务管理*/
public class 书章节Service实现 implements 书章节Service {
    @Autowired
    private 书章节Repository 章节Dao;
    @Autowired
    private 书章节内容Repository 章节内容Dao;
    @Autowired
    private 书章节内容图片Repository 内容图片Dao;
    @Autowired
    阿里云OSS配置信息Repository 阿里云OSSDao;
    @Override
    public void 保存(书章节Entity 书章节) {
        章节Dao.save(书章节);
    }

    @Override
    public 书章节Entity 保存并返回新建对象(书章节Entity 书章节) {
        书章节Entity 保存的对象 = 章节Dao.save(书章节);
        return 保存的对象;
    }

    @Override
    public 书章节Entity 根据Id获取书章节(Long id) {
        书章节Entity 章节 = new 书章节Entity();
        Optional<书章节Entity> op = 章节Dao.findById(id);
        if(op.isPresent())
        {
            章节 = op.get();
        }
        return 章节;
    }

    @Override
    public List<书章节Entity> 根据BookId获取书章节(Long bookId) {
        书章节Entity 章节含子章节 = new 书章节Entity();
        List<书章节Entity> 总章节列表 = new ArrayList<书章节Entity>();
        List<书章节Entity> 含子章节的总章节列表 = new ArrayList<书章节Entity>();


        总章节列表 = 章节Dao.findByBookId(bookId);
        for(int i = 0;i<总章节列表.size();i++)
        {
            List<书章节Entity> 子章节列表 = new ArrayList<书章节Entity>();
            章节含子章节 = 总章节列表.get(i);
            for(int j = 0;j<总章节列表.size();j++)
            {
                if(总章节列表.get(j).getParentId() == 章节含子章节.getId())
                {
                    子章节列表.add(总章节列表.get(j));
                }
            }
            if(子章节列表.size() > 0 )
            {
                章节含子章节.setChildrenMenuList(子章节列表);
            }
            章节含子章节.setChildrenMenuSize(子章节列表.size());

            含子章节的总章节列表.add(章节含子章节);
        }
        return 含子章节的总章节列表;
    }

    @Override
    public List<书章节Entity> 获取所有书章节() {
        return 章节Dao.findAll();
    }

    @Override
    public void 更新(书章节Entity chapter) {

        书章节Entity 章节 = 章节Dao.findById(chapter.getId()).get();
        BeanUtils.copyProperties(chapter,章节);
        章节Dao.save(章节);
    }

    @Override
    public void 删除(书章节Entity chapter) {
        章节Dao.delete(chapter);
        章节内容Dao.delete(章节内容Dao.findById(chapter.getId()).get());
    }

    @Override
    public void 批量删除(List chapterIds) {

        /* 有子章节的不能删除，暂时还未实现此功能 */

        章节Dao.批量删除(chapterIds);
        章节内容Dao.批量删除(chapterIds); /* 关联删除章节内容 */

        阿里云OSSUtil ali = new 阿里云OSSUtil(阿里云OSSDao.findById(1).get());
        for(int i=0;i<chapterIds.size();i++) /* 关联删除章节内容图片 */
        {
            Long 章节内容Id = (Long) chapterIds.get(i);
            List<书章节内容图片Entity> list内容图片 = 内容图片Dao.findByChapterContentId(章节内容Id);
            List<Long> List图片id = new ArrayList();
            for(int j=0;j<list内容图片.size();j++)
            {
                List图片id.add(list内容图片.get(j).getId());
                ali.删除文件(list内容图片.get(j).getUrl());
                System.out.println("+++++++++++++++"+list内容图片.get(j).getUrl());
            }
            内容图片Dao.根据Ids批量删除(List图片id);

        }

    }
}
